/*  Small compiler - code generation (unoptimized "assembler" code)
 *
 *  Copyright (c) ITB CompuPhase, 1997-2003
 *
 *  This software is provided "as-is", without any express or implied warranty.
 *  In no event will the authors be held liable for any damages arising from
 *  the use of this software.
 *
 *  Permission is granted to anyone to use this software for any purpose,
 *  including commercial applications, and to alter it and redistribute it
 *  freely, subject to the following restrictions:
 *
 *  1.  The origin of this software must not be misrepresented; you must not
 *      claim that you wrote the original software. If you use this software in
 *      a product, an acknowledgment in the product documentation would be
 *      appreciated but is not required.
 *  2.  Altered source versions must be plainly marked as such, and must not be
 *      misrepresented as being the original software.
 *  3.  This notice may not be removed or altered from any source distribution.
 *
 *  Version: $Id: embryo_cc_sc4.c 56354 2011-01-29 03:19:51Z raster $
 */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <limits.h>		/* for PATH_MAX */
#include <string.h>

#include "embryo_cc_sc.h"

/* When a subroutine returns to address 0, the AMX must halt. In earlier
 * releases, the RET and RETN opcodes checked for the special case 0 address.
 * Today, the compiler simply generates a HALT instruction at address 0. So
 * a subroutine can savely return to 0, and then encounter a HALT.
 */
void writeleader(void) {
	assert(code_idx == 0);
	stgwrite(";program exit point\n");
	stgwrite("\thalt 0\n");
	/* calculate code length */
	code_idx += opcodes(1) + opargs(1);
}

/*  writetrailer
 *  Not much left of this once important function.
 *
 *  Global references: sc_stksize       (referred to only)
 *                     sc_dataalign     (referred to only)
 *                     code_idx         (altered)
 *                     glb_declared     (altered)
 */
void writetrailer(void) {
	assert(sc_dataalign % opcodes(1) == 0);
	/* alignment must be a multiple of
	 * the opcode size */
	assert(sc_dataalign != 0);

	/* pad code to align data segment */
	if ((code_idx % sc_dataalign) != 0) {
		begcseg();
		while ((code_idx % sc_dataalign) != 0)
			nooperation();
	} /* if */

	/* pad data segment to align the stack and the heap */
	assert(litidx == 0);
	/* literal queue should have been emptied */
	assert(sc_dataalign % sizeof(cell) == 0);
	if (((glb_declared * sizeof(cell)) % sc_dataalign) != 0) {
		begdseg();
		defstorage();
		while (((glb_declared * sizeof(cell)) % sc_dataalign) != 0) {
			stgwrite("0 ");
			glb_declared++;
		} /* while */
	} /* if */

	stgwrite("\nSTKSIZE "); /* write stack size (align stack top) */
	outval(sc_stksize - (sc_stksize % sc_dataalign), TRUE);
}

/*
 *  Start (or restart) the CODE segment.
 *
 *  In fact, the code and data segment specifiers are purely informational;
 *  the "DUMP" instruction itself already specifies that the following values
 *  should go to the data segment. All otherinstructions go to the code
 *  segment.
 *
 *  Global references: curseg
 */
void begcseg(void) {
	if (curseg != sIN_CSEG) {
		stgwrite("\n");
		stgwrite("CODE\t; ");
		outval(code_idx, TRUE);
		curseg = sIN_CSEG;
	} /* endif */
}

/*
 *  Start (or restart) the DATA segment.
 *
 *  Global references: curseg
 */
void begdseg(void) {
	if (curseg != sIN_DSEG) {
		stgwrite("\n");
		stgwrite("DATA\t; ");
		outval(glb_declared - litidx, TRUE);
		curseg = sIN_DSEG;
	} /* if */
}

void setactivefile(int fnumber) {
	stgwrite("curfile ");
	outval(fnumber, TRUE);
}

cell nameincells(char *name) {
	cell clen = (strlen(name) + sizeof(cell)) & ~(sizeof(cell) - 1);
	return clen;
}

void setfile(char *name, int fileno) {
	if ((sc_debug & sSYMBOLIC) != 0) {
		begcseg();
		stgwrite("file ");
		outval(fileno, FALSE);
		stgwrite(" ");
		stgwrite(name);
		stgwrite("\n");
		/* calculate code length */
		code_idx += opcodes(1) + opargs(2) + nameincells(name);
	} /* if */
}

void setline(int line, int fileno) {
	if ((sc_debug & (sSYMBOLIC | sCHKBOUNDS)) != 0) {
		stgwrite("line ");
		outval(line, FALSE);
		stgwrite(" ");
		outval(fileno, FALSE);
		stgwrite("\t; ");
		outval(code_idx, TRUE);
		code_idx += opcodes(1) + opargs(2);
	} /* if */
}

/*  setlabel
 *
 *  Post a code label (specified as a number), on a new line.
 */
void setlabel(int number) {
	assert(number >= 0);
	stgwrite("l.");
	stgwrite((char *) itoh(number));
	/* To assist verification of the assembled code, put the address of the
	 * label as a comment. However, labels that occur inside an expression
	 * may move (through optimization or through re-ordering). So write the
	 * address only if it is known to accurate.
	 */
	if (!staging) {
		stgwrite("\t\t; ");
		outval(code_idx, FALSE);
	} /* if */
	stgwrite("\n");
}

/* Write a token that signifies the end of an expression, or the end of a
 * function parameter. This allows several simple optimizations by the peephole
 * optimizer.
 */
void endexpr(int fullexpr) {
	if (fullexpr)
		stgwrite("\t;$exp\n");
	else
		stgwrite("\t;$par\n");
}

/*  startfunc   - declare a CODE entry point (function start)
 *
 *  Global references: funcstatus  (referred to only)
 */
void startfunc(char *fname) {
	stgwrite("\tproc");
	stgwrite("\n");
	code_idx += opcodes(1);
}

/*  endfunc
 *
 *  Declare a CODE ending point (function end)
 */
void endfunc(void) {
	stgwrite("\n"); /* skip a line */
}

/*  alignframe
 *
 *  Aligns the frame (and the stack) of the current function to a multiple
 *  of the specified byte count. Two caveats: the alignment ("numbytes") should
 *  be a power of 2, and this alignment must be done right after the frame
 *  is set up (before the first variable is declared)
 */
void alignframe(int numbytes) {
#if !defined NDEBUG
	/* "numbytes" should be a power of 2 for this code to work */
	int i, count = 0;

	for (i = 0; i < (int) (sizeof(numbytes) * 8); i++)
		if (numbytes & (1 << i))
			count++;
	assert(count == 1);
#endif

	stgwrite("\tlctrl 4\n"); /* get STK in PRI */
	stgwrite("\tconst.alt "); /* get ~(numbytes-1) in ALT */
	outval(~(numbytes - 1), TRUE);
	stgwrite("\tand\n"); /* PRI = STK "and" ~(numbytes-1) */
	stgwrite("\tsctrl 4\n"); /* set the new value of STK ... */
	stgwrite("\tsctrl 5\n"); /* ... and FRM */
	code_idx += opcodes(5) + opargs(4);
}

/*  Define a variable or function
 */
void defsymbol(char *name, int ident, int vclass, cell offset, int tag) {
	if ((sc_debug & sSYMBOLIC) != 0) {
		begcseg(); /* symbol definition in code segment */
		stgwrite("symbol ");

		stgwrite(name);
		stgwrite(" ");

		outval(offset, FALSE);
		stgwrite(" ");

		outval(vclass, FALSE);
		stgwrite(" ");

		outval(ident, TRUE);

		code_idx += opcodes(1) + opargs(3) + nameincells(name); /* class and ident encoded in "flags" */

		/* also write the optional tag */
		if (tag != 0) {
			assert((tag & TAGMASK) != 0);
			stgwrite("symtag ");
			outval(tag & TAGMASK, TRUE);
			code_idx += opcodes(1) + opargs(1);
		} /* if */
	} /* if */
}

void symbolrange(int level, cell size) {
	if ((sc_debug & sSYMBOLIC) != 0) {
		begcseg(); /* symbol definition in code segment */
		stgwrite("srange ");
		outval(level, FALSE);
		stgwrite(" ");
		outval(size, TRUE);
		code_idx += opcodes(1) + opargs(2);
	} /* if */
}

/*  rvalue
 *
 *  Generate code to get the value of a symbol into "primary".
 */
void rvalue(value * lval) {
	symbol *sym;

	sym = lval->sym;
	if (lval->ident == iARRAYCELL) {
		/* indirect fetch, address already in PRI */
		stgwrite("\tload.i\n");
		code_idx += opcodes(1);
	} else if (lval->ident == iARRAYCHAR) {
		/* indirect fetch of a character from a pack, address already in PRI */
		stgwrite("\tlodb.i ");
		outval(charbits / 8, TRUE); /* read one or two bytes */
		code_idx += opcodes(1) + opargs(1);
	} else if (lval->ident == iREFERENCE) {
		/* indirect fetch, but address not yet in PRI */
		assert(sym != NULL);
		assert(sym->vclass == sLOCAL);
		/* global references don't exist in Small */
		if (sym->vclass == sLOCAL)
			stgwrite("\tlref.s.pri ");
		else
			stgwrite("\tlref.pri ");
		outval(sym->addr, TRUE);
		markusage(sym, uREAD);
		code_idx += opcodes(1) + opargs(1);
	} else {
		/* direct or stack relative fetch */
		assert(sym != NULL);
		if (sym->vclass == sLOCAL)
			stgwrite("\tload.s.pri ");
		else
			stgwrite("\tload.pri ");
		outval(sym->addr, TRUE);
		markusage(sym, uREAD);
		code_idx += opcodes(1) + opargs(1);
	} /* if */
}

/*
 *  Get the address of a symbol into the primary register (used for arrays,
 *  and for passing arguments by reference).
 */
void address(symbol * sym) {
	assert(sym != NULL);
	/* the symbol can be a local array, a global array, or an array
	 * that is passed by reference.
	 */
	if (sym->ident == iREFARRAY || sym->ident == iREFERENCE) {
		/* reference to a variable or to an array; currently this is
		 * always a local variable */
		stgwrite("\tload.s.pri ");
	} else {
		/* a local array or local variable */
		if (sym->vclass == sLOCAL)
			stgwrite("\taddr.pri ");
		else
			stgwrite("\tconst.pri ");
	} /* if */
	outval(sym->addr, TRUE);
	markusage(sym, uREAD);
	code_idx += opcodes(1) + opargs(1);
}

/*  store
 *
 *  Saves the contents of "primary" into a memory cell, either directly
 *  or indirectly (at the address given in the alternate register).
 */
void store(value * lval) {
	symbol *sym;

	sym = lval->sym;
	if (lval->ident == iARRAYCELL) {
		/* store at address in ALT */
		stgwrite("\tstor.i\n");
		code_idx += opcodes(1);
	} else if (lval->ident == iARRAYCHAR) {
		/* store at address in ALT */
		stgwrite("\tstrb.i ");
		outval(charbits / 8, TRUE); /* write one or two bytes */
		code_idx += opcodes(1) + opargs(1);
	} else if (lval->ident == iREFERENCE) {
		assert(sym != NULL);
		if (sym->vclass == sLOCAL)
			stgwrite("\tsref.s.pri ");
		else
			stgwrite("\tsref.pri ");
		outval(sym->addr, TRUE);
		code_idx += opcodes(1) + opargs(1);
	} else {
		assert(sym != NULL);
		markusage(sym, uWRITTEN);
		if (sym->vclass == sLOCAL)
			stgwrite("\tstor.s.pri ");
		else
			stgwrite("\tstor.pri ");
		outval(sym->addr, TRUE);
		code_idx += opcodes(1) + opargs(1);
	} /* if */
}

/* source must in PRI, destination address in ALT. The "size"
 * parameter is in bytes, not cells.
 */
void memcopy(cell size) {
	stgwrite("\tmovs ");
	outval(size, TRUE);

	code_idx += opcodes(1) + opargs(1);
}

/* Address of the source must already have been loaded in PRI
 * "size" is the size in bytes (not cells).
 */
void copyarray(symbol * sym, cell size) {
	assert(sym != NULL);
	/* the symbol can be a local array, a global array, or an array
	 * that is passed by reference.
	 */
	if (sym->ident == iREFARRAY) {
		/* reference to an array; currently this is always a local variable */
		assert(sym->vclass == sLOCAL);
		/* symbol must be stack relative */
		stgwrite("\tload.s.alt ");
	} else {
		/* a local or global array */
		if (sym->vclass == sLOCAL)
			stgwrite("\taddr.alt ");
		else
			stgwrite("\tconst.alt ");
	} /* if */
	outval(sym->addr, TRUE);
	markusage(sym, uWRITTEN);

	code_idx += opcodes(1) + opargs(1);
	memcopy(size);
}

void fillarray(symbol * sym, cell size, cell val) {
	const1(val); /* load val in PRI */

	assert(sym != NULL);
	/* the symbol can be a local array, a global array, or an array
	 * that is passed by reference.
	 */
	if (sym->ident == iREFARRAY) {
		/* reference to an array; currently this is always a local variable */
		assert(sym->vclass == sLOCAL);
		/* symbol must be stack relative */
		stgwrite("\tload.s.alt ");
	} else {
		/* a local or global array */
		if (sym->vclass == sLOCAL)
			stgwrite("\taddr.alt ");
		else
			stgwrite("\tconst.alt ");
	} /* if */
	outval(sym->addr, TRUE);
	markusage(sym, uWRITTEN);

	stgwrite("\tfill ");
	outval(size, TRUE);

	code_idx += opcodes(2) + opargs(2);
}

/*
 *  Instruction to get an immediate value into the primary register
 */
void const1(cell val) {
	if (val == 0) {
		stgwrite("\tzero.pri\n");
		code_idx += opcodes(1);
	} else {
		stgwrite("\tconst.pri ");
		outval(val, TRUE);
		code_idx += opcodes(1) + opargs(1);
	} /* if */
}

/*
 *  Instruction to get an immediate value into the secondary register
 */
void const2(cell val) {
	if (val == 0) {
		stgwrite("\tzero.alt\n");
		code_idx += opcodes(1);
	} else {
		stgwrite("\tconst.alt ");
		outval(val, TRUE);
		code_idx += opcodes(1) + opargs(1);
	} /* if */
}

/* Copy value in secondary register to the primary register */
void moveto1(void) {
	stgwrite("\tmove.pri\n");
	code_idx += opcodes(1) + opargs(0);
}

/*
 *  Push primary register onto the stack
 */
void push1(void) {
	stgwrite("\tpush.pri\n");
	code_idx += opcodes(1);
}

/*
 *  Push alternate register onto the stack
 */
void push2(void) {
	stgwrite("\tpush.alt\n");
	code_idx += opcodes(1);
}

/*
 *  Push a constant value onto the stack
 */
void pushval(cell val) {
	stgwrite("\tpush.c ");
	outval(val, TRUE);
	code_idx += opcodes(1) + opargs(1);
}

/*
 *  pop stack to the primary register
 */
void pop1(void) {
	stgwrite("\tpop.pri\n");
	code_idx += opcodes(1);
}

/*
 *  pop stack to the secondary register
 */
void pop2(void) {
	stgwrite("\tpop.alt\n");
	code_idx += opcodes(1);
}

/*
 *  swap the top-of-stack with the value in primary register
 */
void swap1(void) {
	stgwrite("\tswap.pri\n");
	code_idx += opcodes(1);
}

/* Switch statements
 * The "switch" statement generates a "case" table using the "CASE" opcode.
 * The case table contains a list of records, each record holds a comparison
 * value and a label to branch to on a match. The very first record is an
 * exception: it holds the size of the table (excluding the first record) and
 * the label to branch to when none of the values in the case table match.
 * The case table is sorted on the comparison value. This allows more advanced
 * abstract machines to sift the case table with a binary search.
 */
void ffswitch(int label) {
	stgwrite("\tswitch ");
	outval(label, TRUE); /* the label is the address of the case table */
	code_idx += opcodes(1) + opargs(1);
}

void ffcase(cell val, char *labelname, int newtable) {
	if (newtable) {
		stgwrite("\tcasetbl\n");
		code_idx += opcodes(1);
	} /* if */
	stgwrite("\tcase ");
	outval(val, FALSE);
	stgwrite(" ");
	stgwrite(labelname);
	stgwrite("\n");
	code_idx += opcodes(0) + opargs(2);
}

/*
 *  Call specified function
 */
void ffcall(symbol * sym, int numargs) {
	assert(sym != NULL);
	assert(sym->ident == iFUNCTN);
	if ((sym->usage & uNATIVE) != 0) {
		/* reserve a SYSREQ id if called for the first time */
		if (sc_status == statWRITE && (sym->usage & uREAD) == 0
				&& sym->addr >= 0)
			sym->addr = ntv_funcid++;
		stgwrite("\tsysreq.c ");
		outval(sym->addr, FALSE);
		stgwrite("\n\tstack ");
		outval((numargs + 1) * sizeof(cell), TRUE);
		code_idx += opcodes(2) + opargs(2);
	} else {
		/* normal function */
		stgwrite("\tcall ");
		stgwrite(sym->name);
		stgwrite("\n");
		code_idx += opcodes(1) + opargs(1);
	} /* if */
}

/*  Return from function
 *
 *  Global references: funcstatus  (referred to only)
 */
void ffret(void) {
	stgwrite("\tretn\n");
	code_idx += opcodes(1);
}

void ffabort(int reason) {
	stgwrite("\thalt ");
	outval(reason, TRUE);
	code_idx += opcodes(1) + opargs(1);
}

void ffbounds(cell size) {
	if ((sc_debug & sCHKBOUNDS) != 0) {
		stgwrite("\tbounds ");
		outval(size, TRUE);
		code_idx += opcodes(1) + opargs(1);
	} /* if */
}

/*
 *  Jump to local label number (the number is converted to a name)
 */
void jumplabel(int number) {
	stgwrite("\tjump ");
	outval(number, TRUE);
	code_idx += opcodes(1) + opargs(1);
}

/*
 *   Define storage (global and static variables)
 */
void defstorage(void) {
	stgwrite("dump ");
}

/*
 *  Inclrement/decrement stack pointer. Note that this routine does
 *  nothing if the delta is zero.
 */
void modstk(int delta) {
	if (delta) {
		stgwrite("\tstack ");
		outval(delta, TRUE);
		code_idx += opcodes(1) + opargs(1);
	} /* if */
}

/* set the stack to a hard offset from the frame */
void setstk(cell val) {
	stgwrite("\tlctrl 5\n"); /* get FRM */
	assert(val <= 0);
	/* STK should always become <= FRM */
	if (val < 0) {
		stgwrite("\tadd.c ");
		outval(val, TRUE); /* add (negative) offset */
		code_idx += opcodes(1) + opargs(1);
		// ??? write zeros in the space between STK and the val in PRI (the new stk)
		//     get val of STK in ALT
		//     zero PRI
		//     need new FILL opcode that takes a variable size
	} /* if */
	stgwrite("\tsctrl 4\n"); /* store in STK */
	code_idx += opcodes(2) + opargs(2);
}

void modheap(int delta) {
	if (delta) {
		stgwrite("\theap ");
		outval(delta, TRUE);
		code_idx += opcodes(1) + opargs(1);
	} /* if */
}

void setheap_pri(void) {
	stgwrite("\theap "); /* ALT = HEA++ */
	outval(sizeof(cell), TRUE);
	stgwrite("\tstor.i\n"); /* store PRI (default value) at address ALT */
	stgwrite("\tmove.pri\n"); /* move ALT to PRI: PRI contains the address */
	code_idx += opcodes(3) + opargs(1);
}

void setheap(cell val) {
	stgwrite("\tconst.pri "); /* load default val in PRI */
	outval(val, TRUE);
	code_idx += opcodes(1) + opargs(1);
	setheap_pri();
}

/*
 *  Convert a cell number to a "byte" address; i.e. double or quadruple
 *  the primary register.
 */
void cell2addr(void) {
#if defined(BIT16)
	stgwrite("\tshl.c.pri 1\n");
#else
	stgwrite("\tshl.c.pri 2\n");
#endif
	code_idx += opcodes(1) + opargs(1);
}

/*
 *  Double or quadruple the alternate register.
 */
void cell2addr_alt(void) {
#if defined(BIT16)
	stgwrite("\tshl.c.alt 1\n");
#else
	stgwrite("\tshl.c.alt 2\n");
#endif
	code_idx += opcodes(1) + opargs(1);
}

/*
 *  Convert "distance of addresses" to "number of cells" in between.
 *  Or convert a number of packed characters to the number of cells (with
 *  truncation).
 */
void addr2cell(void) {
#if defined(BIT16)
	stgwrite("\tshr.c.pri 1\n");
#else
	stgwrite("\tshr.c.pri 2\n");
#endif
	code_idx += opcodes(1) + opargs(1);
}

/* Convert from character index to byte address. This routine does
 * nothing if a character has the size of a byte.
 */
void char2addr(void) {
	if (charbits == 16) {
		stgwrite("\tshl.c.pri 1\n");
		code_idx += opcodes(1) + opargs(1);
	} /* if */
}

/* Align PRI (which should hold a character index) to an address.
 * The first character in a "pack" occupies the highest bits of
 * the cell. This is at the lower memory address on Big Endian
 * computers and on the higher address on Little Endian computers.
 * The ALIGN.pri/alt instructions must solve this machine dependence;
 * that is, on Big Endian computers, ALIGN.pri/alt shuold do nothing
 * and on Little Endian computers they should toggle the address.
 */
void charalign(void) {
	stgwrite("\talign.pri ");
	outval(charbits / 8, TRUE);
	code_idx += opcodes(1) + opargs(1);
}

/*
 *  Add a constant to the primary register.
 */
void addconst(cell val) {
	if (val != 0) {
		stgwrite("\tadd.c ");
		outval(val, TRUE);
		code_idx += opcodes(1) + opargs(1);
	} /* if */
}

/*
 *  signed multiply of primary and secundairy registers (result in primary)
 */
void os_mult(void) {
	stgwrite("\tsmul\n");
	code_idx += opcodes(1);
}

/*
 *  signed divide of alternate register by primary register (quotient in
 *  primary; remainder in alternate)
 */
void os_div(void) {
	stgwrite("\tsdiv.alt\n");
	code_idx += opcodes(1);
}

/*
 *  modulus of (alternate % primary), result in primary (signed)
 */
void os_mod(void) {
	stgwrite("\tsdiv.alt\n");
	stgwrite("\tmove.pri\n"); /* move ALT to PRI */
	code_idx += opcodes(2);
}

/*
 *  Add primary and alternate registers (result in primary).
 */
void ob_add(void) {
	stgwrite("\tadd\n");
	code_idx += opcodes(1);
}

/*
 *  subtract primary register from alternate register (result in primary)
 */
void ob_sub(void) {
	stgwrite("\tsub.alt\n");
	code_idx += opcodes(1);
}

/*
 *  arithmic shift left alternate register the number of bits
 *  given in the primary register (result in primary).
 *  There is no need for a "logical shift left" routine, since
 *  logical shift left is identical to arithmic shift left.
 */
void ob_sal(void) {
	stgwrite("\txchg\n");
	stgwrite("\tshl\n");
	code_idx += opcodes(2);
}

/*
 *  arithmic shift right alternate register the number of bits
 *  given in the primary register (result in primary).
 */
void os_sar(void) {
	stgwrite("\txchg\n");
	stgwrite("\tsshr\n");
	code_idx += opcodes(2);
}

/*
 *  logical (unsigned) shift right of the alternate register by the
 *  number of bits given in the primary register (result in primary).
 */
void ou_sar(void) {
	stgwrite("\txchg\n");
	stgwrite("\tshr\n");
	code_idx += opcodes(2);
}

/*
 *  inclusive "or" of primary and secondary registers (result in primary)
 */
void ob_or(void) {
	stgwrite("\tor\n");
	code_idx += opcodes(1);
}

/*
 *  "exclusive or" of primary and alternate registers (result in primary)
 */
void ob_xor(void) {
	stgwrite("\txor\n");
	code_idx += opcodes(1);
}

/*
 *  "and" of primary and secundairy registers (result in primary)
 */
void ob_and(void) {
	stgwrite("\tand\n");
	code_idx += opcodes(1);
}

/*
 *  test ALT==PRI; result in primary register (1 or 0).
 */
void ob_eq(void) {
	stgwrite("\teq\n");
	code_idx += opcodes(1);
}

/*
 *  test ALT!=PRI
 */
void ob_ne(void) {
	stgwrite("\tneq\n");
	code_idx += opcodes(1);
}

/* The abstract machine defines the relational instructions so that PRI is
 * on the left side and ALT on the right side of the operator. For example,
 * SLESS sets PRI to either 1 or 0 depending on whether the expression
 * "PRI < ALT" is true.
 *
 * The compiler generates comparisons with ALT on the left side of the
 * relational operator and PRI on the right side. The XCHG instruction
 * prefixing the relational operators resets this. We leave it to the
 * peephole optimizer to choose more compact instructions where possible.
 */

/* Relational operator prefix for chained relational expressions. The
 * "suffix" code restores the stack.
 * For chained relational operators, the goal is to keep the comparison
 * result "so far" in PRI and the value of the most recent operand in
 * ALT, ready for a next comparison.
 * The "prefix" instruction pushed the comparison result (PRI) onto the
 * stack and moves the value of ALT into PRI. If there is a next comparison,
 * PRI can now serve as the "left" operand of the relational operator.
 */
void relop_prefix(void) {
	stgwrite("\tpush.pri\n");
	stgwrite("\tmove.pri\n");
	code_idx += opcodes(2);
}

void relop_suffix(void) {
	stgwrite("\tswap.alt\n");
	stgwrite("\tand\n");
	stgwrite("\tpop.alt\n");
	code_idx += opcodes(3);
}

/*
 *  test ALT<PRI (signed)
 */
void os_lt(void) {
	stgwrite("\txchg\n");
	stgwrite("\tsless\n");
	code_idx += opcodes(2);
}

/*
 *  test ALT<=PRI (signed)
 */
void os_le(void) {
	stgwrite("\txchg\n");
	stgwrite("\tsleq\n");
	code_idx += opcodes(2);
}

/*
 *  test ALT>PRI (signed)
 */
void os_gt(void) {
	stgwrite("\txchg\n");
	stgwrite("\tsgrtr\n");
	code_idx += opcodes(2);
}

/*
 *  test ALT>=PRI (signed)
 */
void os_ge(void) {
	stgwrite("\txchg\n");
	stgwrite("\tsgeq\n");
	code_idx += opcodes(2);
}

/*
 *  logical negation of primary register
 */
void lneg(void) {
	stgwrite("\tnot\n");
	code_idx += opcodes(1);
}

/*
 *  two's complement primary register
 */
void neg(void) {
	stgwrite("\tneg\n");
	code_idx += opcodes(1);
}

/*
 *  one's complement of primary register
 */
void invert(void) {
	stgwrite("\tinvert\n");
	code_idx += opcodes(1);
}

/*
 *  nop
 */
void nooperation(void) {
	stgwrite("\tnop\n");
	code_idx += opcodes(1);
}

/*  increment symbol
 */
void inc(value * lval) {
	symbol *sym;

	sym = lval->sym;
	if (lval->ident == iARRAYCELL) {
		/* indirect increment, address already in PRI */
		stgwrite("\tinc.i\n");
		code_idx += opcodes(1);
	} else if (lval->ident == iARRAYCHAR) {
		/* indirect increment of single character, address already in PRI */
		stgwrite("\tpush.pri\n");
		stgwrite("\tpush.alt\n");
		stgwrite("\tmove.alt\n"); /* copy address */
		stgwrite("\tlodb.i "); /* read from PRI into PRI */
		outval(charbits / 8, TRUE); /* read one or two bytes */
		stgwrite("\tinc.pri\n");
		stgwrite("\tstrb.i "); /* write PRI to ALT */
		outval(charbits / 8, TRUE); /* write one or two bytes */
		stgwrite("\tpop.alt\n");
		stgwrite("\tpop.pri\n");
		code_idx += opcodes(8) + opargs(2);
	} else if (lval->ident == iREFERENCE) {
		assert(sym != NULL);
		stgwrite("\tpush.pri\n");
		/* load dereferenced value */
		assert(sym->vclass == sLOCAL);
		/* global references don't exist in Small */
		if (sym->vclass == sLOCAL)
			stgwrite("\tlref.s.pri ");
		else
			stgwrite("\tlref.pri ");
		outval(sym->addr, TRUE);
		/* increment */
		stgwrite("\tinc.pri\n");
		/* store dereferenced value */
		if (sym->vclass == sLOCAL)
			stgwrite("\tsref.s.pri ");
		else
			stgwrite("\tsref.pri ");
		outval(sym->addr, TRUE);
		stgwrite("\tpop.pri\n");
		code_idx += opcodes(5) + opargs(2);
	} else {
		/* local or global variable */
		assert(sym != NULL);
		if (sym->vclass == sLOCAL)
			stgwrite("\tinc.s ");
		else
			stgwrite("\tinc ");
		outval(sym->addr, TRUE);
		code_idx += opcodes(1) + opargs(1);
	} /* if */
}

/*  decrement symbol
 *
 *  in case of an integer pointer, the symbol must be incremented by 2.
 */
void dec(value * lval) {
	symbol *sym;

	sym = lval->sym;
	if (lval->ident == iARRAYCELL) {
		/* indirect decrement, address already in PRI */
		stgwrite("\tdec.i\n");
		code_idx += opcodes(1);
	} else if (lval->ident == iARRAYCHAR) {
		/* indirect decrement of single character, address already in PRI */
		stgwrite("\tpush.pri\n");
		stgwrite("\tpush.alt\n");
		stgwrite("\tmove.alt\n"); /* copy address */
		stgwrite("\tlodb.i "); /* read from PRI into PRI */
		outval(charbits / 8, TRUE); /* read one or two bytes */
		stgwrite("\tdec.pri\n");
		stgwrite("\tstrb.i "); /* write PRI to ALT */
		outval(charbits / 8, TRUE); /* write one or two bytes */
		stgwrite("\tpop.alt\n");
		stgwrite("\tpop.pri\n");
		code_idx += opcodes(8) + opargs(2);
	} else if (lval->ident == iREFERENCE) {
		assert(sym != NULL);
		stgwrite("\tpush.pri\n");
		/* load dereferenced value */
		assert(sym->vclass == sLOCAL);
		/* global references don't exist in Small */
		if (sym->vclass == sLOCAL)
			stgwrite("\tlref.s.pri ");
		else
			stgwrite("\tlref.pri ");
		outval(sym->addr, TRUE);
		/* decrement */
		stgwrite("\tdec.pri\n");
		/* store dereferenced value */
		if (sym->vclass == sLOCAL)
			stgwrite("\tsref.s.pri ");
		else
			stgwrite("\tsref.pri ");
		outval(sym->addr, TRUE);
		stgwrite("\tpop.pri\n");
		code_idx += opcodes(5) + opargs(2);
	} else {
		/* local or global variable */
		assert(sym != NULL);
		if (sym->vclass == sLOCAL)
			stgwrite("\tdec.s ");
		else
			stgwrite("\tdec ");
		outval(sym->addr, TRUE);
		code_idx += opcodes(1) + opargs(1);
	} /* if */
}

/*
 *  Jumps to "label" if PRI != 0
 */
void jmp_ne0(int number) {
	stgwrite("\tjnz ");
	outval(number, TRUE);
	code_idx += opcodes(1) + opargs(1);
}

/*
 *  Jumps to "label" if PRI == 0
 */
void jmp_eq0(int number) {
	stgwrite("\tjzer ");
	outval(number, TRUE);
	code_idx += opcodes(1) + opargs(1);
}

/* write a value in hexadecimal; optionally adds a newline */
void outval(cell val, int newline) {
	stgwrite(itoh(val));
	if (newline)
		stgwrite("\n");
}
